home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / BG_SRC.ZIP / BG_DICE.C < prev    next >
C/C++ Source or Header  |  1995-03-25  |  8KB  |  294 lines
  1. /*
  2.  *                        B G _ D I C E . C
  3.  * This module handles all the functions of the Dice.
  4.  * O.F.Ransen:    21st June    1991
  5.  * This version:  22nd January 1993
  6.  *
  7.  */
  8.  
  9. #include <stdlib.h>
  10. #include <stdio.h>
  11. #include <conio.h>
  12. #include "bg.h"
  13.  
  14. /*************************************************************************/
  15.  
  16. Stats_t Statistics [N_PLAYERS] ;
  17. Throw_t Throw = AUTO_THROW ;  /* The computer throws the dice */
  18.  
  19. /*************************************************************************/
  20.  
  21. Dice_t Throw_Dice (Player_t Player,
  22.                    Player_t Opponent,
  23.                    Player_t Human,
  24.                    boolean* Doubled, boolean* Rejected,
  25.                    Layout_t  Curr_Lay[2])
  26. /*
  27. PURPOSE: To throw the two dice and return the values we get. We pass in
  28.          the player in because we need to know which statistics to
  29.          update.
  30. NOTES:   1) Starting to work on doubling cube...
  31. */
  32. {
  33.     extern Mesg_t Messages[N_MESGS] ;
  34.     extern short Lang ;
  35.     extern boolean F10_Hit ;
  36.     Dice_t Dummy_Dice ;
  37.  
  38.     Dummy_Dice.N_Vals = 0 ;
  39.  
  40.     if (Player == Human) {
  41.         (*Doubled) = Human_Doubles (Player) ;
  42.         if (F10_Hit) {
  43.             return (Dummy_Dice) ;
  44.         }
  45.     } else {
  46.         (*Doubled) = Computer_Doubles (Player,Curr_Lay) ;
  47.     }
  48.  
  49.     if (*Doubled) {
  50.         if (Opponent == Human) {
  51.             Framed_Center_String (Messages[YOU_ACC_MSG].Message[Lang],12,PUSH) ;
  52.             (*Rejected) = Human_Rejects_Double () ;
  53.             Erase_Framed_String () ;
  54.             if (F10_Hit) {
  55.                 return (Dummy_Dice) ;
  56.             }
  57.         } else {
  58.             if (Player == BLACK_PLAYER) {
  59.                 Print_Message (BLK_PROP_DBL_MSG) ;
  60.             } else {
  61.                 Print_Message (WHT_PROP_DBL_MSG) ;
  62.             }
  63.             (*Rejected) = Computer_Rejects_Double (Opponent,Curr_Lay) ;
  64.         }
  65.     }
  66.  
  67.     if ((*Doubled) && (*Rejected)) {
  68.         if (Player == Human) {
  69.             Print_Message (COM_REJ_MSG) ;
  70.         } else {
  71.             if (Player == BLACK_PLAYER) {
  72.                 Print_Message (WHT_REJ_DBL_MSG) ;
  73.             } else {
  74.                 Print_Message (BLK_REJ_DBL_MSG) ;
  75.             }
  76.         }
  77.         return (Dummy_Dice) ;
  78.     } else {
  79.         if (*Doubled) {
  80.             extern int      Double_Value ;
  81.             extern Player_t Double_Possessor ;
  82.  
  83.             Double_Value     = Double_Value * 2 ;
  84.             Double_Possessor = Opponent ;
  85.             Draw_Double_Cube (Double_Possessor,Double_Value) ;
  86.             if (Player == Human) {
  87.                 Print_Message (COM_ACC_MSG) ;
  88.             } else {
  89.                 if (Player == BLACK_PLAYER) {
  90.                     Print_Message (WHT_ACC_DBL_MSG) ;
  91.                 } else {
  92.                     Print_Message (BLK_ACC_DBL_MSG) ;
  93.                 }
  94.             }
  95.         }
  96.         if (Throw == AUTO_THROW) {
  97.             return (Computer_Throws_Dice (Player)) ;
  98.         } else {
  99.             return (Human_Throws_Dice (Player,Player)) ;
  100.         }
  101.     }
  102. }
  103.  
  104. /*************************************************************************/
  105.  
  106. Dice_t Computer_Throws_Dice (Player_t George)
  107. /*
  108. PURPOSE: To get the computer to generate the dice.
  109. */
  110. {
  111.     Dice_t Throw ;
  112.     short n,Score ;
  113.     int Rand_Rolls,r ;
  114.     extern boolean Genetics ;
  115.  
  116.     if (Genetics) {
  117.         Rand_Rolls = 1 ;
  118.     } else {
  119.         Rand_Rolls = Int_Rand_Range (MIN_ROLLS,MAX_ROLLS) ;
  120.     }
  121.     for (r = 0 ; r < Rand_Rolls ; r++) {
  122.         Throw.Values[0] = (char)Int_Rand_Range (1,6) ;
  123.         Throw.Values[1] = (char)Int_Rand_Range (1,6) ;
  124.         Throw.N_Vals    = 2 ;
  125.         Draw_Dice_Pair (&Throw,George) ;
  126.     }
  127.  
  128.     if (Throw.Values[0] == Throw.Values[1]) {
  129.         /* Lucky George, he threw a double */
  130.         Throw.Values[2] = Throw.Values[0] ;
  131.         Throw.Values[3] = Throw.Values[0] ;
  132.         Throw.N_Vals    = 4 ;
  133.         Statistics [George].Doubles ++ ;
  134.     } else {
  135.         Throw.Values[2] = 0 ;
  136.         Throw.Values[3] = 0 ;
  137.         Throw.N_Vals    = 2 ;
  138.     }
  139.  
  140.     Statistics [George].N_Throws ++ ;
  141.     Score = 0 ;
  142.     for (n = 0 ; n < Throw.N_Vals ; n++) {
  143.         Score += Throw.Values[n] ;
  144.     }
  145.     Statistics [George].Total += Score ;
  146.  
  147.     // !!!!OWEN!!!!
  148.     // Throw.N_Vals = 2 ;
  149.     // Throw.Values[0] = 1 ;
  150.     // Throw.Values[1] = 4 ;
  151.  
  152.  
  153.     return (Throw) ;
  154. }
  155.  
  156. /**********************************************************************/
  157.  
  158. Dice_t Human_Throws_Dice (Player_t First, Player_t Second)
  159. /*
  160. PURPOSE: To get the human to input the dice.
  161. NOTES:   1) Usually First == Second and is either BLACK_PLAYER or
  162.          WHITE_PLAYER. On the first throw tho First != Second and
  163.          dice of different colours have to be drawn.
  164.          2) If the user at any point hits F10 then we set F10_Hit.
  165. */
  166. {
  167.     extern boolean F10_Hit ;
  168.     Dice_t Throw ;
  169.     short Score,d,Key ;
  170.     Player_t List[N_PLAYERS] ;
  171.  
  172.     List [0] = First ;
  173.     List [1] = Second ;
  174.  
  175.     if (First == Second) {
  176.         Print_Message (THROW_DICE_MSG) ;
  177.     } else {
  178.         Print_Message (INIT_DICE_MSG) ;
  179.     }
  180.  
  181.     Throw.N_Vals = 0 ;
  182.     Key          = 0 ;
  183.  
  184.     Clear_Die (1) ;
  185.     Clear_Die (2) ;
  186.  
  187.     while ((Throw.N_Vals != 2) || (Key != ENTER_KEY)) {
  188.         Key = getch () ;
  189.         if (Key == FUN_PREFIX) {
  190.             if (getch () == F10_KEY) {
  191.                 F10_Hit = TRUE ;
  192.                 Throw.N_Vals = 0 ;
  193.                 Clear_Help_Line () ;
  194.                 return (Throw) ;
  195.             }
  196.         } else if ((Key > '0') && (Key < '7') && (Throw.N_Vals < 2)) {
  197.             Throw.Values[Throw.N_Vals] = (char)(Key - (short)'0') ;
  198.             Throw.N_Vals++ ;
  199.         } else if ((Key == BACK_KEY) && (Throw.N_Vals > 0)) {
  200.             Throw.N_Vals-- ;
  201.         } else if (Key == ESC_KEY) {
  202.             Throw.N_Vals = 0 ;
  203.         }
  204.         for (d = 0 ; d < 2 ; d++) {
  205.             if (d < Throw.N_Vals) {
  206.                 Draw_Die (Throw.Values[d],d+1,List[d]) ;
  207.             } else {
  208.                 Clear_Die (d+1) ;
  209.             }
  210.         }
  211.     }
  212.  
  213.     if (First == Second) {
  214.         /* This is a throw of a single player, update his stats */
  215.         if (Throw.Values[0] == Throw.Values[1]) {
  216.             /* Lucky George, he threw a double */
  217.             Throw.Values[2] = Throw.Values[0] ;
  218.             Throw.Values[3] = Throw.Values[0] ;
  219.             Throw.N_Vals    = 4 ;
  220.             Statistics [First].Doubles ++ ;
  221.         }
  222.  
  223.         Statistics [First].N_Throws ++ ;
  224.         Score = 0 ;
  225.         for (d = 0 ; d < Throw.N_Vals ; d++) {
  226.             Score += Throw.Values[d] ;
  227.         }
  228.         Statistics [First].Total += Score ;
  229.     }
  230.     Clear_Help_Line () ;
  231.     return (Throw) ;
  232. }
  233.  
  234. /**********************************************************************/
  235.  
  236. void Init_Stats (void)
  237. /*
  238. PURPOSE: To reset all the statistics.
  239. */
  240. {
  241.     ushort p ;
  242.     for (p=0 ; p < N_PLAYERS ; p++) {
  243.         Statistics[p].Total      =     0 ;
  244.         Statistics[p].N_Throws   =     0 ;
  245.         Statistics[p].Doubles    =     0 ;
  246.         Statistics[p].Games_Won = 0 ;
  247.     }
  248. }
  249.  
  250. /***************************************************************************/
  251.  
  252. void Copy_Dice (Dice_t* Dest, Dice_t* Source)
  253. /*
  254. PURPOSE: To copy the dice.
  255. */
  256. {
  257.     short i ;
  258.     Dest->N_Vals = Source->N_Vals ;
  259.     for (i = 0 ; i < Source->N_Vals ; i++) {
  260.         Dest->Values[i] = Source->Values[i] ;
  261.     }
  262. }
  263.  
  264. /***************************************************************************/
  265.  
  266. void Deplete_Dice_Pool (Dice_t* Dice, ushort Index)
  267. /*
  268. PURPOSE: To remove a dice from the pool.
  269. */
  270. {
  271.     ushort i ;
  272.  
  273.     if (Index > 3) {
  274.         Error_Exit ("\nDepleting a dice which does not exist.") ;
  275.     } else if (Index > (ushort)Dice->N_Vals-1) {
  276.         Error_Exit ("\nDepleting more dice than I have.") ;
  277.     } else if (Dice->N_Vals == 0) {
  278.         Error_Exit ("\nAll dice used up") ;
  279.     } else if (Dice->N_Vals > 4) {
  280.         Error_Exit ("\nToo many dice") ;
  281.     }
  282.  
  283.     i = Index ;
  284.     while (i < (ushort)Dice->N_Vals-1) {
  285.         Dice->Values[i] = Dice->Values[i+1] ;
  286.         i++ ;
  287.     }
  288.  
  289.     Dice->N_Vals-- ;
  290. }
  291.  
  292. /***************************************************************************/
  293.  
  294.